home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / TOKEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  8.2 KB  |  570 lines
  1.  
  2. /* token.c - The pogo tokenizer. */
  3.  
  4. #include <stdio.h>
  5. #include <ctype.h>
  6. #include "pogo.h"
  7.  
  8. extern char *pget_line();
  9.  
  10. char *title;    
  11. char line_buf[SZTOKE];
  12. char *line_pos;
  13. int line_count = 0;
  14.  
  15. /* variables maintained by next_token() */
  16. char ctoke[SZTOKE];
  17. Symbol *csym;
  18. int cint;
  19. int cttype;
  20. int reuse;
  21. Symbol *global_hash[256];
  22.  
  23.  
  24. #ifdef CCODE
  25. /* trivial utility routines */
  26. copy_bytes(s, d, count)
  27. register char *s, *d;
  28. register int count;
  29. {
  30. while (--count >= 0)
  31.     *d++ = *s++;
  32. }
  33. #endif CCODE
  34.  
  35. zero_bytes(d, count)
  36. register char *d;
  37. register int count;
  38. {
  39. while (--count >= 0)
  40.     *d++ = 0;
  41. }
  42.  
  43. dupe_bytes(d, val, count)
  44. register char *d, val;
  45. register int count;
  46. {
  47. while (--count >= 0)
  48.     *d++ = val;
  49. }
  50.  
  51. upper_case(s)
  52. register unsigned char *s;
  53. {
  54. register unsigned char c;
  55.  
  56. while ((c = *s) != 0)
  57.     {
  58.     if (islower(c))
  59.         *s += 'A' - 'a';
  60.     s++;
  61.     }
  62. }
  63.  
  64. jstrcmp(a,b)
  65. register char *a, *b;
  66. {
  67.  
  68. if (a == b)
  69.     return(0);
  70. else if (a == NULL)
  71.     return(1);
  72. else if (b == NULL)
  73.     return(-1);
  74. else
  75.     {
  76.     return(strcmp(a,b));
  77.     }
  78. }
  79.  
  80.  
  81. /*  Some memory allocation routines */
  82. void *
  83. beg_mem(size)
  84. unsigned size;
  85. {
  86. char *pt;
  87.  
  88. pt = askmem(size);
  89. if (pt == NULL)
  90.     {
  91.     outta_memory();
  92.     }
  93. return(pt);
  94. }
  95.  
  96. void *
  97. beg_zero(size)
  98. int size;
  99. {
  100. char *pt;
  101.  
  102. if ((pt = (char *)beg_mem(size)) != NULL)
  103.     zero_bytes(pt, size);
  104. return(pt);
  105. }
  106.  
  107. char *
  108. clone_string(s)
  109. char *s;
  110. {
  111. int size;
  112. char *d;
  113.  
  114. if (s == NULL)
  115.     return(NULL);
  116. size = strlen(s)+1;
  117. if ((d = (char *)beg_mem(size)) != NULL)
  118.     copy_bytes(s, d, size);
  119. return(d);
  120. }
  121.  
  122. /* actually frees a generic list, not just a name list */
  123. free_list(list)
  124. Names *list;
  125. {
  126. Names *next;
  127.  
  128. while (list)
  129.     {
  130.     next = list->next;
  131.     freemem(list);
  132.     list = next;
  133.     }
  134. }
  135.  
  136. /* Symbol table management routines */
  137. int
  138. hash_function(string)
  139. register unsigned char *string;
  140. {
  141. register int a, hash;
  142.  
  143. hash = 0;
  144. while ((a = *string++)!= NULL)
  145.     {
  146.     hash <<= 1;
  147.     hash ^= a;
  148.     }
  149. return(hash & 0xff);
  150. }
  151.  
  152. add_hash(s)
  153. Symbol *s;
  154. {
  155. int hash;
  156.  
  157. hash = hash_function(s->name);
  158. s->next = global_hash[hash];
  159. global_hash[hash] = s;
  160. }
  161.  
  162. new_frame()
  163. {
  164. struct pogo_frame *pf;
  165.  
  166. if ((pf = (struct pogo_frame *)beg_zero(sizeof(*pf) ) ) == NULL)
  167.     return(0);
  168. pf->parent = rframe;
  169. rframe = pf;
  170. return(1);
  171. }
  172.  
  173. old_frame()
  174. {
  175. struct pogo_frame *pf;
  176.  
  177. if (rframe != NULL)
  178.     {
  179.     pf = rframe->parent;
  180.     freemem(rframe);
  181.     rframe = pf;
  182.     }
  183. }
  184.  
  185. Symbol *
  186. named_symbol(name, type, scope)
  187. char *name;
  188. int type;
  189. int scope;
  190. {
  191. Symbol *ns;
  192.  
  193. if ((ns = (Symbol *)beg_zero(sizeof(*ns))) == NULL)
  194.     return(NULL);
  195. if ((ns->name = clone_string(name)) == NULL)
  196.     {
  197.     freemem(ns);
  198.     return(NULL);
  199.     }
  200. ns->type = type;
  201. ns->scope = scope;
  202. ns->tok_type = TOK_VAR;
  203. return(ns);
  204. }
  205.  
  206. Symbol *
  207. new_symbol(name, type, scope, frame)
  208. char *name;
  209. int type;
  210. struct pogo_frame *frame;
  211. {
  212. Symbol *ns;
  213.  
  214. if ((ns = named_symbol(name, type, scope)) != NULL)
  215.     {
  216.     if (scope == LOCAL)
  217.         {
  218.         ns->next = frame->symbols;
  219.         frame->symbols = ns;
  220.         }
  221.     else
  222.         {
  223.         add_hash(ns);
  224.         }
  225.     }
  226. return(ns);
  227. }
  228.  
  229.  
  230. Symbol *
  231. in_list(l, name)
  232. register Symbol *l;
  233. char *name;
  234. {
  235. while (l != NULL)
  236.     {
  237.     if (strcmp(l->name, name) == 0)
  238.         return(l);
  239.     l = l->next;
  240.     }
  241. return(NULL);
  242. }
  243.  
  244. Symbol *
  245. in_hash(name)
  246. char *name;
  247. {
  248. return(in_list(global_hash[hash_function(name)], name) );
  249. }
  250.  
  251. Symbol *
  252. find_symbol(name)
  253. char *name;
  254. {
  255. struct pogo_frame *p;
  256. Symbol *s;
  257.  
  258. if ((s = in_hash(name)) != NULL)
  259.     return(s);
  260. if ((s = in_list(rframe->symbols, name)) != NULL)
  261.     return(s);
  262. return(NULL);
  263. }
  264.  
  265. /* chop word ... put the next word in line
  266.    into the buffer word points to, return what's left of the line, or
  267.    NULL if at end of line */
  268. char *
  269. chop_word(line, oword)
  270. register char *line;
  271. char *oword;
  272. {
  273. register char c;
  274. register char *word;
  275.  
  276.  
  277. word = oword;
  278.  
  279. while (isspace(*line) )
  280.     line++;
  281. c = *line;
  282. if (c == 0)
  283.     return(NULL);
  284. else if (iscsymf(c) )
  285.     {
  286.     cttype = TOK_UNDEF;
  287.     *word++ = c;
  288.     line++;
  289.     for (;;)
  290.         {
  291.         c = *line;
  292.         if (!iscsym(c) )
  293.             break;
  294.         *word++ = c;
  295.         line++;
  296.         }
  297.     oword[MAX_SYM_LEN-1] = 0;        /* chop long symbols */
  298.     }
  299. else if (isdigit(c) )
  300.     {
  301.     if (c == '0' && (line[1] == 'x' || line[1] == 'X'))
  302.         {
  303.         *word++ = 0;
  304.         *word++ = 'x';
  305.         line += 2;
  306.         for (;;)
  307.             {
  308.             c = *line;
  309.             if (!isxdigit(c))
  310.                 break;
  311.             *word++ = c;
  312.             line++;
  313.             }
  314.         }
  315.     for (;;)
  316.         {
  317.         c = *line;
  318.         if (!isdigit(c) )
  319.             break;
  320.         *word++ = c;
  321.         line++;
  322.         }
  323.     cttype = TOK_NUM;
  324.     }
  325. else if (c == '"')
  326.     {
  327.     cttype = TOK_QUO;
  328.     line++;
  329.     for (;;)
  330.         {
  331.         c = *line;
  332.         if (c == 0)
  333.             {
  334.             unmatched("\"");
  335.             break;
  336.             }
  337.         if( c == '"')
  338.             {
  339.             line++;
  340.             break;
  341.             }
  342.         *word++ = c;
  343.         line++;
  344.         }
  345.     }
  346. else if (c == TOK_SQUO)
  347.     {
  348.     if (line[2] != TOK_SQUO)
  349.         unmatched("'");
  350.     *word++ = line[1];
  351.     line += 3;
  352.     cttype = TOK_SQUO;
  353.     }
  354. else
  355.     {
  356.     /* process non-alphanumeric characters.  Most will be passed through
  357.        as single character tokens.  Some, like ==, !=, >= and <= are
  358.        easier to handle here than in parser (which only has one token
  359.        look-ahead. */
  360.     switch (c)
  361.         {
  362.         case '=':
  363.             if (line[1] == '=')    /* double equals */
  364.                 {
  365.                 *word++ = '=';
  366.                 *word++ = '=';
  367.                 line += 2;
  368.                 cttype = TOK_EQ;
  369.                 }
  370.             else
  371.                 goto SIMPLE;
  372.             break;
  373.         case '!':
  374.             if (line[1] == '=')    /* != */
  375.                 {
  376.                 *word++ = '!';
  377.                 *word++ = '=';
  378.                 line += 2;
  379.                 cttype = TOK_NE;
  380.                 }
  381.             else
  382.                 goto SIMPLE;
  383.             break;
  384.         case '<':
  385.             if (line[1] == '=')    /* <= */
  386.                 {
  387.                 *word++ = '<';
  388.                 *word++ = '=';
  389.                 line += 2;
  390.                 cttype = TOK_LE;
  391.                 }
  392.             else if (line[1] == '<')    /* << */
  393.                 {
  394.                 *word++ = '<';
  395.                 *word++ = '<';
  396.                 line += 2;
  397.                 cttype = TOK_LSHIFT;
  398.                 }
  399.             else if (line[1] == '>')    /* <> */
  400.                 {
  401.                 *word++ = '<';
  402.                 *word++ = '>';
  403.                 line += 2;
  404.                 cttype = TOK_NE;
  405.                 }
  406.             else
  407.                 goto SIMPLE;
  408.             break;
  409.         case '>':
  410.             if (line[1] == '=')    /* >= */
  411.                 {
  412.                 *word++ = '>';
  413.                 *word++ = '=';
  414.                 line += 2;
  415.                 cttype = TOK_GE;
  416.                 }
  417.             else if (line[1] == '>')    /* >> */
  418.                 {
  419.                 *word++ = '>';
  420.                 *word++ = '>';
  421.                 line += 2;
  422.                 cttype = TOK_RSHIFT;
  423.                 }
  424.             else
  425.                 goto SIMPLE;
  426.             break;
  427.         case '&':
  428.             if (line[1] == '&')    /* logical and - && */
  429.                 {
  430.                 *word++ = '&';
  431.                 *word++ = '&';
  432.                 line += 2;
  433.                 cttype = TOK_LAND;
  434.                 }
  435.             else
  436.                 goto SIMPLE;
  437.             break;
  438.         case '|':
  439.             if (line[1] == '|')    /* logical or - || */
  440.                 {
  441.                 *word++ = '|';
  442.                 *word++ = '|';
  443.                 line += 2;
  444.                 cttype = TOK_LOR;
  445.                 }
  446.             else
  447.                 goto SIMPLE;
  448.             break;
  449.         default:
  450. SIMPLE:
  451.             cttype = *word++ = c;
  452.             line++;
  453.             break;
  454.         }
  455.     }
  456. *word++ = 0;
  457. return(line);
  458. }
  459.     
  460.  
  461. /* make us reuse last token.  Can only pushback one token though */
  462. pushback_token()
  463. {
  464. if (reuse)
  465.     {
  466.     say_fatal("Double pushback");
  467.     }
  468. reuse = 1;
  469. }
  470.  
  471. /* Hex to int */
  472. htoi(s)
  473. char *s;
  474. {
  475. int acc;
  476. char c;
  477.  
  478. acc = 0;
  479. while ((c = *s++) != 0)
  480.     {
  481.     acc <<= 4;
  482.     if (isdigit(c))
  483.         acc += c - '0';
  484.     else if (c >= 'a' && c <= 'f')
  485.         acc += (c - 'a' + 10);
  486.     else if (c >= 'A' && c <= 'F')
  487.         acc += (c - 'A' + 10);
  488.     }
  489. return(acc);
  490. }
  491.  
  492. /* Next token - fetches next word from input into ctoke, and classifies
  493.    it with cttype. Determines if a plain old word is a variable. */
  494. next_token()
  495. {
  496. if (reuse)
  497.     {
  498.     reuse = 0;
  499.     return(1);
  500.     }
  501. for (;;)
  502.     {
  503.     if (line_pos == NULL)
  504.         {
  505.         line_count++;
  506.         if ((line_pos = pget_line(line_buf, sizeof(line_buf))) == NULL)
  507.             {
  508.             puts("EOF");
  509.             got_eof = got_stop = 1;
  510.             return(0);
  511.             }
  512.         }
  513.     if ((line_pos = chop_word(line_pos, ctoke)) != NULL)
  514.         {
  515.         if (cttype == ';')    /* line to right of ; ignored */
  516.             line_pos = NULL;
  517.         else
  518.             break;
  519.         }
  520.     }
  521. if (cttype == TOK_UNDEF)
  522.     {
  523.     upper_case(ctoke);
  524.     if ((csym = find_symbol(ctoke)) != NULL)
  525.         cttype = csym->tok_type;
  526.     }
  527. else if (cttype == TOK_NUM)
  528.     {
  529.     if (ctoke[1] == 'x')
  530.         {
  531.         cint = htoi(ctoke+2);
  532.         }
  533.     else
  534.         cint = atoi(ctoke);
  535.     }
  536. else if (cttype == TOK_SQUO)
  537.     {
  538.     cttype = TOK_NUM;
  539.     cint = ctoke[0];
  540.     }
  541. return(1);
  542. }
  543.  
  544.  
  545. free_literals()
  546. {
  547. Names *next;
  548.  
  549. while (literals)
  550.     {
  551.     freemem(literals->name);
  552.     next = literals->next;
  553.     freemem(literals);
  554.     literals = next;
  555.     }
  556. }
  557.  
  558.  
  559.  
  560. need_token()
  561. {
  562. if (!next_token())
  563.     {
  564.     truncated(title);
  565.     return(0);
  566.     }
  567. return(1);
  568. }
  569.  
  570.